////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxbpslsc34.h
/// @brief bpslsc34 class declarations
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef CAMXBPSLSC34_H
#define CAMXBPSLSC34_H

// Camx Includes
#include "bps_data.h"
#include "camxispiqmodule.h"
#include "lsc_3_4_0.h"
#include "tintless_2_0_0.h"
#include "titan170_bps.h"

// Common library includes
#include "iqcommondefs.h"

CAMX_NAMESPACE_BEGIN

CAMX_BEGIN_PACKED

/// @brief LSC register Configuration
struct BPSLSC34RegConfig
{
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_0_CFG   config0;    ///< Lens Rolloff config 0
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_1_CFG   config1;    ///< Lens Rolloff config 1
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_2_CFG   config2;    ///< Lens Rolloff config 2
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_3_CFG   config3;    ///< Lens Rolloff config 3
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_4_CFG   config4;    ///< Lens Rolloff config 4
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_5_CFG   config5;    ///< Lens Rolloff config 5
    BPS_BPS_0_CLC_LENS_ROLLOFF_LENS_ROLLOFF_6_CFG   config6;    ///< Lens Rolloff config 6
} CAMX_PACKED;

CAMX_END_PACKED

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief BPS LSC 34 Class Implementation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class BPSLSC34 final : public ISPIQModule
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Create BPSLSC34 Object
    ///
    /// @param  pCreateData Pointer to the BPSLSC34 Creation
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult Create(
        BPSModuleCreateData* pCreateData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Initialize
    ///
    /// @brief  Initialize parameters
    ///
    /// @param  pInputData Pointer to the Inputdata
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Initialize(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Execute
    ///
    /// @brief  Execute process capture request to configure module
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Execute(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~BPSLSC34
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~BPSLSC34();

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BPSLSC34
    ///
    /// @brief  Constructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BPSLSC34();

private:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AllocateCommonLibraryData
    ///
    /// @brief  Allocate memory required for common library
    ///
    /// @return CamxResult success if the write operation is success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult AllocateCommonLibraryData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DeallocateCommonLibraryData
    ///
    /// @brief  Deallocate memory required for common library
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID DeallocateCommonLibraryData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TranslateCalibrationTableToCommonLibrary
    ///
    /// @brief  Translate calibration table to common library
    ///
    /// @param  pInputData Pointer to the Input Data
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID TranslateCalibrationTableToCommonLibrary(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CheckDependenceChange
    ///
    /// @brief  Check to see if the Dependence Trigger Data Changed
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return TRUE if dependencies met
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CheckDependenceChange(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RunCalculation
    ///
    /// @brief  Calculate the Register Value
    ///
    /// @param  pInputData       Pointer to the ISP input data
    /// @param  pLscModuleConfig Pointer to the module configuration parameters
    ///
    /// @return CamxResult Indicates if configure DMI and Registers was success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult RunCalculation(
        const ISPInputData*    pInputData,
        LensRollOffParameters* pLscModuleConfig);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FetchDMIBuffer
    ///
    /// @brief  Fetch DMI buffer
    ///
    /// @param  pInputData Pointer to the LSC Module Input data
    ///
    /// @return CamxResult Indicates if configure DMI was success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult FetchDMIBuffer(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// WriteLUTtoDMI
    ///
    /// @brief  Write Look up table data pointer into DMI header
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult Indicates if write to DMI header was success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult WriteLUTtoDMI(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DumpRegConfig
    ///
    /// @brief  Print register configuration of LSC module for debug
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID DumpRegConfig() const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateBPSInternalData
    ///
    /// @brief  Update BPS internal data
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID UpdateBPSInternalData(
        const ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateCmdList
    ///
    /// @brief  Create the Command List
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateCmdList(
        const ISPInputData* pInputData);

    BPSLSC34(const BPSLSC34&)            = delete;                     ///< Disallow the copy constructor
    BPSLSC34& operator=(const BPSLSC34&) = delete;                     ///< Disallow assignment operator

    BPSLSC34RegConfig                         m_regCmd;                ///< Register list for LSC module
    CmdBufferManager*                         m_pLUTCmdBufferManager;  ///< Command buffer manager for all LUTs of LSC
    CmdBuffer*                                m_pLUTDMICmdBuffer;      ///< Command buffer for holding all LUTs
    LSC34InputData                            m_dependenceData;        ///< Dependence Data for this Module
    LSCCalibrationData*                       m_pLSCCalibrationData;   ///< LSC Calibration table
    OSLIBRARYHANDLE                           m_hHandle;               ///< Tintless Algo Library handle
    CHITintlessAlgorithm*                     m_pTintlessAlgo;         ///< Tintless Algorithm Instance
    TintlessConfig                            m_tintlessConfig;        ///< Tintless Config
    ParsedTintlessBGStatsOutput*              m_pTintlessBGStats;      ///< Pointer to TintlessBG stats
    UINT32*                                   m_pGRRLUTDMIBuffer;      ///< Tuning pointer to GRR LSC mesh table
    UINT32*                                   m_pGBBLUTDMIBuffer;      ///< Tuning pointer to GBB SC mesh table
    LSC34UnpackedData                         m_unpackedData;          ///< unpacked data
    UINT8                                     m_shadingMode;           ///< Shading mode
    UINT8                                     m_lensShadingMapMode;    ///< Lens shading map mode
    lsc_3_4_0::chromatix_lsc34Type*           m_pChromatix;            ///< Pointer to tuning mode data
    tintless_2_0_0::chromatix_tintless20Type* m_pTinlessChromatix;     ///
    BOOL                                      m_AWBLock;               ///< Flag to track AWB state
};

CAMX_NAMESPACE_END

#endif // CAMXBPSLSC34_H
